//策略模式
//    亦称： Strategy
//    意图
//
//策略模式是一种行为设计模式， 它能让你定义一系列算法， 并将每种算法分别放入独立的类中， 以使算法的对象能够相互替换。
#include <iostream>
#include <vector>

/**
 * The Strategy interface declares operations common to all supported versions
 * of some algorithm.
 *
 * The Context uses this interface to call the algorithm defined by Concrete
 * Strategies.
 */
class Strategy
{
public:
  virtual ~Strategy() {}
  virtual std::string DoAlgorithm(const std::vector<std::string> &data) const = 0;
};

/**
 * The Context defines the interface of interest to clients.
 */

class Context
{
  /**
   * @var Strategy The Context maintains a reference to one of the Strategy
   * objects. The Context does not know the concrete class of a strategy. It
   * should work with all strategies via the Strategy interface.
   */
private:
  Strategy *strategy_;
  /**
   * Usually, the Context accepts a strategy through the constructor, but also
   * provides a setter to change it at runtime.
   */
public:
  Context(Strategy *strategy = nullptr) : strategy_(strategy)
  {
  }
  ~Context()
  {
    delete this->strategy_;
  }
  /**
   * Usually, the Context allows replacing a Strategy object at runtime.
   */
  void set_strategy(Strategy *strategy)
  {
    delete this->strategy_;
    this->strategy_ = strategy;
  }
  /**
   * The Context delegates some work to the Strategy object instead of
   * implementing +multiple versions of the algorithm on its own.
   */
  void DoSomeBusinessLogic() const
  {
    // ...
    std::cout << "Context: Sorting data using the strategy (not sure how it'll do it)\n";
    std::string result = this->strategy_->DoAlgorithm(std::vector<std::string>{"a", "e", "c", "b", "d"});
    std::cout << result << "\n";
    // ...
  }
};

/**
 * Concrete Strategies implement the algorithm while following the base Strategy
 * interface. The interface makes them interchangeable in the Context.
 */
class ConcreteStrategyA : public Strategy
{
public:
  std::string DoAlgorithm(const std::vector<std::string> &data) const override
  {
    std::string result;
    std::for_each(std::begin(data), std::end(data), [&result](const std::string &letter) {
      result += letter;
    });
    std::sort(std::begin(result), std::end(result));

    return result;
  }
};
class ConcreteStrategyB : public Strategy
{
  std::string DoAlgorithm(const std::vector<std::string> &data) const override
  {
    std::string result;
    std::for_each(std::begin(data), std::end(data), [&result](const std::string &letter) {
      result += letter;
    });
    std::sort(std::begin(result), std::end(result));
    for (int i = 0; i < result.size() / 2; i++)
    {
      std::swap(result[i], result[result.size() - i - 1]);
    }

    return result;
  }
};
/**
 * The client code picks a concrete strategy and passes it to the context. The
 * client should be aware of the differences between strategies in order to make
 * the right choice.
 */

void ClientCode()
{
  Context *context = new Context(new ConcreteStrategyA);
  std::cout << "Client: Strategy is set to normal sorting.\n";
  context->DoSomeBusinessLogic();
  std::cout << "\n";
  std::cout << "Client: Strategy is set to reverse sorting.\n";
  context->set_strategy(new ConcreteStrategyB);
  context->DoSomeBusinessLogic();
  delete context;
}

int main()
{
  ClientCode();
  return 0;
}